import { z } from 'zod';
import { ValidationError } from './errors.js';

/**
 * 密码强度验证
 */
export function validatePasswordStrength(password) {
  const minLength = 8;
  const errors = [];
  
  if (password.length < minLength) {
    errors.push(`密码至少${minLength}个字符`);
  }
  
  if (!/[A-Z]/.test(password)) {
    errors.push('密码必须包含至少一个大写字母');
  }
  
  if (!/[a-z]/.test(password)) {
    errors.push('密码必须包含至少一个小写字母');
  }
  
  if (!/[0-9]/.test(password)) {
    errors.push('密码必须包含至少一个数字');
  }
  
  return {
    valid: errors.length === 0,
    errors,
  };
}

/**
 * 邮箱验证
 */
export function validateEmail(email) {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(email);
}

/**
 * 用户名验证
 */
export function validateUsername(username) {
  const errors = [];
  
  if (username.length < 3) {
    errors.push('用户名至少3个字符');
  }
  
  if (username.length > 50) {
    errors.push('用户名最多50个字符');
  }
  
  if (!/^[a-zA-Z0-9_-]+$/.test(username)) {
    errors.push('用户名只能包含字母、数字、下划线和连字符');
  }
  
  return {
    valid: errors.length === 0,
    errors,
  };
}

// ==================== Zod Schemas ====================

/**
 * 用户注册验证
 */
export const registerSchema = z.object({
  username: z.string().min(3).max(50).regex(/^[a-zA-Z0-9_-]+$/),
  email: z.string().email(),
  password: z.string().min(8),
});

/**
 * 用户登录验证
 */
export const loginSchema = z.object({
  username: z.string().optional(),
  email: z.string().email().optional(),
  password: z.string(),
}).refine(data => data.username || data.email, {
  message: '必须提供用户名或邮箱',
});

/**
 * 修改密码验证
 */
export const changePasswordSchema = z.object({
  oldPassword: z.string(),
  newPassword: z.string().min(8),
});

/**
 * 创建令牌验证
 */
export const createTokenSchema = z.object({
  serviceName: z.string().min(1).max(100),
  accountName: z.string().max(100).optional(),
  secret: z.string().min(1), // TOTP密钥
  algorithm: z.enum(['SHA1', 'SHA256', 'SHA512']).default('SHA1'),
  digits: z.number().int().min(6).max(8).default(6),
  period: z.number().int().positive().default(30),
  tokenType: z.enum(['TOTP', 'HOTP']).default('TOTP'),
  category: z.string().max(50).optional(),
  tags: z.array(z.string()).optional(),
  iconUrl: z.string().url().optional(),
  notes: z.string().max(1000).optional(),
});

/**
 * 更新令牌验证
 */
export const updateTokenSchema = z.object({
  serviceName: z.string().min(1).max(100).optional(),
  accountName: z.string().max(100).optional(),
  category: z.string().max(50).optional(),
  tags: z.array(z.string()).optional(),
  iconUrl: z.string().url().optional(),
  notes: z.string().max(1000).optional(),
  isFavorite: z.boolean().optional(),
  sortOrder: z.number().int().optional(),
});

/**
 * 创建分类验证
 */
export const createCategorySchema = z.object({
  name: z.string().min(1).max(50),
  color: z.string().max(20).optional(),
  icon: z.string().max(50).optional(),
  sortOrder: z.number().int().default(0),
});

/**
 * 更新用户验证（管理员）
 */
export const updateUserSchema = z.object({
  email: z.string().email().optional(),
  role: z.enum(['user', 'admin']).optional(),
  isActive: z.boolean().optional(),
  notes: z.string().optional(),
});

/**
 * 用户偏好设置验证
 */
export const userPreferencesSchema = z.object({
  theme: z.enum(['auto', 'light', 'dark']).default('auto'),
  language: z.string().default('zh-CN'),
  timezone: z.string().default('Asia/Shanghai'),
  defaultTokenPeriod: z.number().int().default(30),
  autoCopyOnClick: z.boolean().default(true),
  showAccountName: z.boolean().default(true),
  notificationEnabled: z.boolean().default(false),
});

/**
 * 验证请求数据
 */
export function validateRequest(schema, data) {
  try {
    return schema.parse(data);
  } catch (error) {
    if (error instanceof z.ZodError) {
      const errors = error.errors.map(err => ({
        field: err.path.join('.'),
        message: err.message,
      }));
      throw new ValidationError('VALIDATION_ERROR', '验证失败', errors);
    }
    throw error;
  }
}


